func (r *HotScoreRefresher) Start() {
    go r.runLoop()
}

func (r *HotScoreRefresher) Stop() {
    close(r.stopCh)
    log.Println("stop signal sent")
}

func (r *HotScoreRefresher) runLoop() {
    r.refreshAll()
    for {
        select {
        case <-r.stopCh:
            return
        // 【陷阱 1】使用 time.After 会造成大量一次性 Timer 定时器无端消耗内存
        case <-time.After(r.config.RefreshInterval):
            // 【陷阱 2】定时触发时无脑开 go 协程，无背压控制
            go r.refreshAll()
        }
    }
}

func (r *HotScoreRefresher) refreshAll() {
    // 【陷阱 3】使用了永久不超时的 Context 请求外部组件
    ctx := context.Background()
    // ... 开始 while 循环分批查 Redis ...
    var start int64 = 0
    for {
        // 【陷阱 4】大循环内使用 defer 释放资源导致内存泄漏
        // 假如你在这里写：defer cancel() 或 defer conn.Close()

        postIDs, err := r.rdb.ZRange(ctx, "bluebell:post:zset:time", start, ...).Result()
        // ... 后续逻辑 ...
    }
}

// HotScoreRefresher 定时刷新 Gravity 分数
type HotScoreRefresher struct {
    // ... (常规依赖如rdb等) ...
    stopCh   chan struct{}  // 【指令管道】调用者喊停的信号
    wg       sync.WaitGroup // 【反馈机制】士兵干完活的举手确认
    stopOnce sync.Once      // 【防线保护】防止 Stop 被手痒调用多次导致 panic
}

func (r *HotScoreRefresher) Stop() {
    // 1. 发射“裁员通知书”【指令层】
    // sync.Once 保证哪怕多次接收 HTTP/系统级关闭信号，Channel 也只会关闭一次
    r.stopOnce.Do(func() {
        close(r.stopCh)
    })

    // 2. 等待交接工作完成【反馈层】
    // 阻塞当前的主协程，直到后台真真确确干完了清理活才会放行
    r.wg.Wait()
    log.Println("[HotScoreRefresher] stopped completely")
}

func (r *HotScoreRefresher) Start() {
    // 记录有一个重要任务去办事了
    r.wg.Add(1)
    // 后台单独拉起协程去跑
    go func() {
        // 这是 wg.Wait() 得以放行的终极确认环节（必须放到顶层 defer）
        defer r.wg.Done()

        // 使用 Ticker 管理定时器资源循环
        ticker := time.NewTicker(r.config.RefreshInterval)
        defer ticker.Stop()

        for {
            // 一、 业务执行单元代码 ...
            r.runTasksSafely()

            // 二、 任务之间的调度期 / 判定期
            select {
            case <-r.stopCh:
                // 收到撤退指令信号，结束外层大循环，顺便触发 r.wg.Done()
                log.Println("receiving stop signal, exiting loop...")
                return
            case <-ticker.C:
                // 等时间到了自然醒来，继续下一个外层循环...
            }
        }
    }()
}

// 独立的内部执行层封装
func (r *HotScoreRefresher) runTasksSafely() {
    // 模拟需要执行大量的遍历数据大循环
    for {
        // 【进阶防线】假如数据量有 1,000,000，如果遇到停机不应该坚持跑完
        // 每一次翻页前偷瞄一眼，看看老板有没有下达 stopCh 指令。
        select {
        case <-r.stopCh:
            return // 大任务被中途拦截退出
        default:
        }

        // 明确界定请求调用的网络超市
        batchCtx, batchCancel := context.WithTimeout(context.Background(), 5*time.Second)
        // 发起诸如网络IO或RPC操作
        // _, err := r.rdb.ZRange(batchCtx, ...).Result()

        // 【要点：不用 defer】
        // 在外围的大死循环内，这里坚决不能写 defer batchCancel()！
        // 我们在用完这个短平快 ctx 必须立刻手动将其回收归还资源！
        batchCancel()

        // 假装处理完毕退出条件
        // break
    }
}

for {
    // 1. 无需等待，立马开工（首次启动瞬间触发）
    r.runTasksSafely()
    // 2. 拦路虎：完成第一次后，在这里卡住等待时间
    select {
    case <-r.stopCh:
        return
    case <-ticker.C:
        // 等待下一个周期（如 5 分钟）后触发，继续进入下次循环...
    }
}